home *** CD-ROM | disk | FTP | other *** search
/ InterCD 2000 September / september_2000.iso / intercd / root / ^Linux / WindowMaker / WINGs / data.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-03-30  |  7.6 KB  |  335 lines
  1. /*
  2.  *  WINGs WMData function library
  3.  * 
  4.  *  Copyright (c) 1999 Dan Pascu
  5.  * 
  6.  *  This program is free software; you can redistribute it and/or modify
  7.  *  it under the terms of the GNU General Public License as published by
  8.  *  the Free Software Foundation; either version 2 of the License, or
  9.  *  (at your option) any later version.
  10.  *
  11.  *  This program is distributed in the hope that it will be useful,
  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  *  GNU General Public License for more details.
  15.  *
  16.  *  You should have received a copy of the GNU General Public License
  17.  *  along with this program; if not, write to the Free Software
  18.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  */
  20.  
  21.  
  22.  
  23. #include <string.h>
  24. #include "WUtil.h"
  25.  
  26.  
  27. typedef struct W_Data {
  28.     unsigned   length;      /* How many bytes we have */
  29.     unsigned   capacity;    /* How many bytes it can hold */
  30.     unsigned   growth;      /* How much to grow */
  31.     void       *bytes;      /* Actual data */
  32.     unsigned   retainCount;
  33.     unsigned   freeData:1;  /* whether the data should be released */
  34. } W_Data;
  35.  
  36.  
  37.  
  38.  
  39. /* Creating and destroying data objects */
  40.  
  41. WMData*
  42. WMCreateDataWithCapacity(unsigned capacity) /*FOLD00*/
  43. {
  44.     WMData *aData;
  45.  
  46.     aData = (WMData*)wmalloc(sizeof(WMData));
  47.  
  48.     if (capacity>0)
  49.         aData->bytes = wmalloc(capacity);
  50.     else
  51.         aData->bytes = NULL;
  52.     aData->capacity = capacity;
  53.     aData->growth = capacity/2 > 0 ? capacity/2 : 1;
  54.     aData->length = 0;
  55.     aData->retainCount = 1;
  56.     aData->freeData = 1;
  57.  
  58.     return aData;
  59. }
  60.  
  61.  
  62. WMData*
  63. WMCreateDataWithLength(unsigned length) /*FOLD00*/
  64. {
  65.     WMData *aData;
  66.  
  67.     aData = WMCreateDataWithCapacity(length);
  68.     if (length>0) {
  69.         memset(aData->bytes, 0, length);
  70.         aData->length = length;
  71.     }
  72.  
  73.     return aData;
  74. }
  75.  
  76.  
  77. WMData*
  78. WMCreateDataWithBytes(void *bytes, unsigned length) /*FOLD00*/
  79. {
  80.     WMData *aData;
  81.  
  82.     aData = WMCreateDataWithCapacity(length);
  83.     aData->length = length;
  84.     memcpy(aData->bytes, bytes, length);
  85.  
  86.     return aData;
  87. }
  88.  
  89.  
  90. WMData*
  91. WMCreateDataWithBytesNoCopy(void *bytes, unsigned length) /*FOLD00*/
  92. {
  93.     WMData *aData;
  94.  
  95.     aData = (WMData*)wmalloc(sizeof(WMData));
  96.     aData->length = length;
  97.     aData->capacity = length;
  98.     aData->growth = length/2 > 0 ? length/2 : 1;
  99.     aData->bytes = bytes;
  100.     aData->retainCount = 1;
  101.     aData->freeData = 0;
  102.  
  103.     return aData;
  104. }
  105.  
  106.  
  107. WMData*
  108. WMCreateDataWithData(WMData *aData) /*FOLD00*/
  109. {
  110.     if (aData->length > 0)
  111.         return WMCreateDataWithBytes(aData->bytes, aData->length);
  112.     else
  113.         return WMCreateDataWithCapacity(0);
  114. }
  115.  
  116.  
  117. WMData*
  118. WMRetainData(WMData *aData) /*FOLD00*/
  119. {
  120.     aData->retainCount++;
  121.     return aData;
  122. }
  123.  
  124.  
  125. void
  126. WMReleaseData(WMData *aData) /*FOLD00*/
  127. {
  128.     aData->retainCount--;
  129.     if (aData->retainCount > 0)
  130.         return;
  131.     if (aData->bytes && aData->freeData)
  132.         wfree(aData->bytes);
  133.     wfree(aData);
  134. }
  135.  
  136.  
  137.  
  138. /* Adjusting capacity */
  139.  
  140. void
  141. WMSetDataCapacity(WMData *aData, unsigned capacity) /*FOLD00*/
  142. {
  143.     if (aData->capacity != capacity) {
  144.         aData->bytes = wrealloc(aData->bytes, capacity);
  145.         aData->capacity = capacity;
  146.         aData->growth = capacity/2 > 0 ? capacity/2 : 1;
  147.     }
  148.     if (aData->length > capacity) {
  149.         aData->length = capacity;
  150.     }
  151. }
  152.  
  153.  
  154. void
  155. WMSetDataLength(WMData *aData, unsigned length) /*FOLD00*/
  156. {
  157.     if (length > aData->capacity) {
  158.         WMSetDataCapacity(aData, length);
  159.     }
  160.     if (length > aData->length) {
  161.         unsigned char    *dataBytes = (unsigned char *)aData->bytes;
  162.  
  163.         memset(dataBytes + aData->length, 0, length - aData->length);
  164.     }
  165.     aData->length = length;
  166. }
  167.  
  168.  
  169. void
  170. WMIncreaseDataLengthBy(WMData *aData, unsigned extraLength) /*FOLD00*/
  171. {
  172.     WMSetDataLength(aData, aData->length + extraLength);
  173. }
  174.  
  175.  
  176. /* Accessing data */
  177.  
  178. const void*
  179. WMDataBytes(WMData *aData) /*FOLD00*/
  180. {
  181.     return aData->bytes;
  182. }
  183.  
  184.  
  185. void
  186. WMGetDataBytes(WMData *aData, void *buffer) /*FOLD00*/
  187. {
  188.     wassertr(aData->length > 0);
  189.  
  190.     memcpy(buffer, aData->bytes, aData->length);
  191. }
  192.  
  193.  
  194. void
  195. WMGetDataBytesWithLength(WMData *aData, void *buffer, unsigned length) /*FOLD00*/
  196. {
  197.     wassertr(aData->length > 0);
  198.     wassertr(length <= aData->length);
  199.  
  200.     memcpy(buffer, aData->bytes, length);
  201. }
  202.  
  203.  
  204. void
  205. WMGetDataBytesWithRange(WMData *aData, void *buffer, WMRange aRange) /*FOLD00*/
  206. {
  207.     unsigned char *dataBytes = (unsigned char *)aData->bytes;
  208.  
  209.     wassertr(aRange.position < aData->length);
  210.     wassertr(aRange.count <= aData->length-aRange.position);
  211.  
  212.     memcpy(buffer,dataBytes + aRange.position, aRange.count);
  213. }
  214.  
  215.  
  216. WMData*
  217. WMGetSubdataWithRange(WMData *aData, WMRange aRange) /*FOLD00*/
  218. {
  219.     void *buffer;
  220.  
  221.     /* return an empty subdata instead if aRange.count is 0 ? */
  222.     wassertrv(aRange.count > 0, NULL);
  223.  
  224.     buffer = wmalloc(aRange.count);
  225.     WMGetDataBytesWithRange(aData, buffer, aRange);
  226.     return WMCreateDataWithBytesNoCopy(buffer, aRange.count);
  227. }
  228.  
  229.  
  230. /* Testing data */
  231.  
  232. Bool
  233. WMIsDataEqualToData(WMData *aData, WMData *anotherData) /*FOLD00*/
  234. {
  235.     if (aData->length != anotherData->length)
  236.         return False;
  237.     else if (!aData->bytes && !anotherData->bytes) /* both are empty */
  238.         return True;
  239.     else if (!aData->bytes || !anotherData->bytes) /* one of them is empty */
  240.         return False;
  241.     return (memcmp(aData->bytes, anotherData->bytes, aData->length)==0);
  242. }
  243.  
  244.  
  245. unsigned
  246. WMGetDataLength(WMData *aData) /*FOLD00*/
  247. {
  248.     return aData->length;
  249. }
  250.  
  251.  
  252. unsigned
  253. WMGetDataHash(WMData *aData) /*FOLD00*/
  254. {
  255.     return aData->length;
  256. }
  257.  
  258.  
  259. /* Adding data */
  260. void
  261. WMAppendDataBytes(WMData *aData, void *bytes, unsigned length) /*FOLD00*/
  262. {
  263.     unsigned oldLength = aData->length;
  264.     unsigned newLength = oldLength + length;
  265.     unsigned char *dataBytes = (unsigned char *)aData->bytes;
  266.  
  267.     if (newLength > aData->capacity) {
  268.         unsigned nextCapacity = aData->capacity + aData->growth;
  269.         unsigned nextGrowth = aData->capacity ? aData->capacity : 1;
  270.  
  271.         while (nextCapacity < newLength) {
  272.             unsigned tmp = nextCapacity + nextGrowth;
  273.  
  274.             nextGrowth = nextCapacity;
  275.             nextCapacity = tmp;
  276.         }
  277.         WMSetDataCapacity(aData, nextCapacity);
  278.         aData->growth = nextGrowth;
  279.     }
  280.     memcpy(dataBytes + oldLength, bytes, length);
  281.     aData->length = newLength;
  282. }
  283.  
  284.  
  285. void
  286. WMAppendData(WMData *aData, WMData *anotherData) /*FOLD00*/
  287. {
  288.     if (anotherData->length > 0)
  289.         WMAppendDataBytes(aData, anotherData->bytes, anotherData->length);
  290. }
  291.  
  292.  
  293.  
  294. /* Modifying data */
  295.  
  296. void
  297. WMReplaceDataBytesInRange(WMData *aData, WMRange aRange, void *bytes) /*FOLD00*/
  298. {
  299.     unsigned char *dataBytes = (unsigned char *)aData->bytes;
  300.  
  301.     wassertr(aRange.position < aData->length);
  302.     wassertr(aRange.count <= aData->length-aRange.position);
  303.  
  304.     memcpy(dataBytes + aRange.position, bytes, aRange.count);
  305. }
  306.  
  307.  
  308. void
  309. WMResetDataBytesInRange(WMData *aData, WMRange aRange) /*FOLD00*/
  310. {
  311.     unsigned char *dataBytes = (unsigned char *)aData->bytes;
  312.  
  313.     wassertr(aRange.position < aData->length);
  314.     wassertr(aRange.count <= aData->length-aRange.position);
  315.  
  316.     memset(dataBytes + aRange.position, 0, aRange.count);
  317. }
  318.  
  319.  
  320. void
  321. WMSetData(WMData *aData, WMData *anotherData) /*FOLD00*/
  322. {
  323.     unsigned length = anotherData->length;
  324.  
  325.     WMSetDataCapacity(aData, length);
  326.     if (length > 0)
  327.         memcpy(aData->bytes, anotherData->bytes, length);
  328.     aData->length = length;
  329. }
  330.  
  331.  
  332. /* Storing data */
  333.  
  334.  
  335.